package cn.hybrid.mx;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {
    //核心线程数为 5
    private static final int CORE_POOL_SIZE = 5;
    //最大线程数 10
    private static final int MAX_POOL_SIZE = 10;
    //任务队列 为 ArrayBlockingQueue，并且容量为 100
    private static final int QUEUE_CAPACITY = 100;
    //等待时间为 1L
    private static final Long KEEP_ALIVE_TIME = 1L;

    /**
     * 在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，
     * 所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。
     * 当前的 5 个任务之行完成后，才会之行剩下的 5 个任务
     * @param args
     */
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        //使用阿里巴巴推荐的创建线程池的方式
        // 通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                //核心线程数为
                CORE_POOL_SIZE,
                //最大线程数
                MAX_POOL_SIZE,
                //等待时间
                KEEP_ALIVE_TIME,
                //等待时间的单位为 TimeUnit.SECONDS。
                TimeUnit.SECONDS,
                //任务队列
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                //饱和策略为 CallerRunsPolicy
                new ThreadPoolExecutor.CallerRunsPolicy());

        for (int i = 0; i < 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
        long end = System.currentTimeMillis();
        System.out.println(end-start);

    }
}
